+Fri Sep 7 20:45:29 2001 Jonathan Blandford <jrb@redhat.com>
+
+ * gtk/gtktreeviewcolumn.c (gtk_tree_view_column_pack_{start,end}):
+ Removed 'fill' attribute. It was silly b/c that was a property of
+ the cell renderer, anyway.
+ (gtk_tree_view_column_render): Actually render the packed
+ renderers.
+ * doc/tree-column-sizing.txt: initial devel documentation.
+ * gtk/gtktreeview.c (gtk_tree_view_expand_all): Fix bug.
+ * gtk/gtkcellrenderertextpixbuf.[ch]: removed.
+
+ * tests/testtreefocus.c: fix up to reflect above changes.
+ * tests/testtreeview.c: ditto
+ * demos/gtk-demo/stock_browser.c: ditto
+
2001-09-07 Alex Larsson <alexl@redhat.com>
* gdk/linux-fb/gdkcolor-fb.c:
+Fri Sep 7 20:45:29 2001 Jonathan Blandford <jrb@redhat.com>
+
+ * gtk/gtktreeviewcolumn.c (gtk_tree_view_column_pack_{start,end}):
+ Removed 'fill' attribute. It was silly b/c that was a property of
+ the cell renderer, anyway.
+ (gtk_tree_view_column_render): Actually render the packed
+ renderers.
+ * doc/tree-column-sizing.txt: initial devel documentation.
+ * gtk/gtktreeview.c (gtk_tree_view_expand_all): Fix bug.
+ * gtk/gtkcellrenderertextpixbuf.[ch]: removed.
+
+ * tests/testtreefocus.c: fix up to reflect above changes.
+ * tests/testtreeview.c: ditto
+ * demos/gtk-demo/stock_browser.c: ditto
+
2001-09-07 Alex Larsson <alexl@redhat.com>
* gdk/linux-fb/gdkcolor-fb.c:
+Fri Sep 7 20:45:29 2001 Jonathan Blandford <jrb@redhat.com>
+
+ * gtk/gtktreeviewcolumn.c (gtk_tree_view_column_pack_{start,end}):
+ Removed 'fill' attribute. It was silly b/c that was a property of
+ the cell renderer, anyway.
+ (gtk_tree_view_column_render): Actually render the packed
+ renderers.
+ * doc/tree-column-sizing.txt: initial devel documentation.
+ * gtk/gtktreeview.c (gtk_tree_view_expand_all): Fix bug.
+ * gtk/gtkcellrenderertextpixbuf.[ch]: removed.
+
+ * tests/testtreefocus.c: fix up to reflect above changes.
+ * tests/testtreeview.c: ditto
+ * demos/gtk-demo/stock_browser.c: ditto
+
2001-09-07 Alex Larsson <alexl@redhat.com>
* gdk/linux-fb/gdkcolor-fb.c:
+Fri Sep 7 20:45:29 2001 Jonathan Blandford <jrb@redhat.com>
+
+ * gtk/gtktreeviewcolumn.c (gtk_tree_view_column_pack_{start,end}):
+ Removed 'fill' attribute. It was silly b/c that was a property of
+ the cell renderer, anyway.
+ (gtk_tree_view_column_render): Actually render the packed
+ renderers.
+ * doc/tree-column-sizing.txt: initial devel documentation.
+ * gtk/gtktreeview.c (gtk_tree_view_expand_all): Fix bug.
+ * gtk/gtkcellrenderertextpixbuf.[ch]: removed.
+
+ * tests/testtreefocus.c: fix up to reflect above changes.
+ * tests/testtreeview.c: ditto
+ * demos/gtk-demo/stock_browser.c: ditto
+
2001-09-07 Alex Larsson <alexl@redhat.com>
* gdk/linux-fb/gdkcolor-fb.c:
+Fri Sep 7 20:45:29 2001 Jonathan Blandford <jrb@redhat.com>
+
+ * gtk/gtktreeviewcolumn.c (gtk_tree_view_column_pack_{start,end}):
+ Removed 'fill' attribute. It was silly b/c that was a property of
+ the cell renderer, anyway.
+ (gtk_tree_view_column_render): Actually render the packed
+ renderers.
+ * doc/tree-column-sizing.txt: initial devel documentation.
+ * gtk/gtktreeview.c (gtk_tree_view_expand_all): Fix bug.
+ * gtk/gtkcellrenderertextpixbuf.[ch]: removed.
+
+ * tests/testtreefocus.c: fix up to reflect above changes.
+ * tests/testtreeview.c: ditto
+ * demos/gtk-demo/stock_browser.c: ditto
+
2001-09-07 Alex Larsson <alexl@redhat.com>
* gdk/linux-fb/gdkcolor-fb.c:
+Fri Sep 7 20:45:29 2001 Jonathan Blandford <jrb@redhat.com>
+
+ * gtk/gtktreeviewcolumn.c (gtk_tree_view_column_pack_{start,end}):
+ Removed 'fill' attribute. It was silly b/c that was a property of
+ the cell renderer, anyway.
+ (gtk_tree_view_column_render): Actually render the packed
+ renderers.
+ * doc/tree-column-sizing.txt: initial devel documentation.
+ * gtk/gtktreeview.c (gtk_tree_view_expand_all): Fix bug.
+ * gtk/gtkcellrenderertextpixbuf.[ch]: removed.
+
+ * tests/testtreefocus.c: fix up to reflect above changes.
+ * tests/testtreeview.c: ditto
+ * demos/gtk-demo/stock_browser.c: ditto
+
2001-09-07 Alex Larsson <alexl@redhat.com>
* gdk/linux-fb/gdkcolor-fb.c:
+Fri Sep 7 20:45:29 2001 Jonathan Blandford <jrb@redhat.com>
+
+ * gtk/gtktreeviewcolumn.c (gtk_tree_view_column_pack_{start,end}):
+ Removed 'fill' attribute. It was silly b/c that was a property of
+ the cell renderer, anyway.
+ (gtk_tree_view_column_render): Actually render the packed
+ renderers.
+ * doc/tree-column-sizing.txt: initial devel documentation.
+ * gtk/gtktreeview.c (gtk_tree_view_expand_all): Fix bug.
+ * gtk/gtkcellrenderertextpixbuf.[ch]: removed.
+
+ * tests/testtreefocus.c: fix up to reflect above changes.
+ * tests/testtreeview.c: ditto
+ * demos/gtk-demo/stock_browser.c: ditto
+
2001-09-07 Alex Larsson <alexl@redhat.com>
* gdk/linux-fb/gdkcolor-fb.c:
}
static void
-macro_set_func (GtkTreeViewColumn *tree_column,
- GtkCellRenderer *cell,
- GtkTreeModel *model,
- GtkTreeIter *iter,
- gpointer data)
+macro_set_func_text (GtkTreeViewColumn *tree_column,
+ GtkCellRenderer *cell,
+ GtkTreeModel *model,
+ GtkTreeIter *iter,
+ gpointer data)
{
StockItemInfo *info;
g_object_set (GTK_CELL_RENDERER (cell),
"text", info->macro,
+ NULL);
+
+ stock_item_info_free (info);
+}
+
+static void
+macro_set_func_pixbuf (GtkTreeViewColumn *tree_column,
+ GtkCellRenderer *cell,
+ GtkTreeModel *model,
+ GtkTreeIter *iter,
+ gpointer data)
+{
+ StockItemInfo *info;
+
+ gtk_tree_model_get (model, iter,
+ 0, &info,
+ -1);
+
+ g_object_set (GTK_CELL_RENDERER (cell),
"pixbuf", info->small_icon,
NULL);
GtkCellRenderer *cell_renderer;
StockItemDisplay *display;
GtkTreeSelection *selection;
-
+ GtkTreeViewColumn *column;
+
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Stock Icons and Items");
gtk_container_add (GTK_CONTAINER (sw), treeview);
- cell_renderer = gtk_cell_renderer_text_pixbuf_new ();
+ column = gtk_tree_view_column_new ();
+ gtk_tree_view_column_set_title (column, "Macro");
+
+ cell_renderer = gtk_cell_renderer_pixbuf_new ();
+ gtk_tree_view_column_pack_start (column,
+ cell_renderer,
+ FALSE);
+ gtk_tree_view_column_set_cell_data_func (column, cell_renderer,
+ macro_set_func_pixbuf, NULL, NULL);
+ cell_renderer = gtk_cell_renderer_text_new ();
+ gtk_tree_view_column_pack_start (column,
+ cell_renderer,
+ TRUE);
+ gtk_tree_view_column_set_cell_data_func (column, cell_renderer,
+ macro_set_func_text, NULL, NULL);
+
+ gtk_tree_view_append_column (GTK_TREE_VIEW (treeview),
+ column);
- gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (treeview),
- -1,
- "Macro",
- cell_renderer,
- macro_set_func,
- NULL,
- NULL);
cell_renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (treeview),
--- /dev/null
+The way that the GtkTreeView calculates sizing is pretty confusing.
+This is written down to help keep track of it in my head, and thus help
+anyone who hopes to work with the code in the future.
+
+HOW THE GTKTREEVIEW CALCULATES SIZE:
+====================================
+When the view is given a new model, the first thing it does is walk
+through the model at the top level, creating an GtkRBNode for each
+element of the model. Each node has a height of 0. The RBTree is kept
+updated as the models structure changes. Additionally, the user can
+expand, collapse, and select rows at this stage. The RBTree is accurate
+-- it just doesn't have a height for any row.
+
+When the TreeView is realized, it calculates the actual height of each
+row by walking the tree and measuring them. While doing so, it gets the
+size of each column.
+
+
+
+Columns are initially marked as 'dirty'. When sized,
+gtk_tree_view_check_dirty_and_clean () is called on each column. This
+function walks through all visible columns, and sees if they're dirty or
+not. If any are dirty, it then walks the tree, calling
+gtk_tree_view_calc_size on each row. gtk_tree_view_calc_size requests
+the size of every dirty column in the tree. Finally, it updates the
+size of the widget (including adjustments).
+
+
+HOW THE GTKTREEVIEWCOLUMN STORES SIZE:
+======================================
+
+There are a number of size related fields in the GtkTreeViewColumn
+structure:
+
+ sizing The sizing method to use when calculating the size
+ of the column. Can be grow_only, resizable, auto, and fixed.
+
+ requested_width The width of the column as requested by the column
+
+ width The actual width. This is requested width for all
+ columns but possibly the last one.
+
+ fixed_width The requested fixed width for the column iff it's
+ sizing type is set to GTK_TREE_VIEW_COLUMN_FIXED.
+
+ min_width The minimum width the column can be
+
+ max_width The maximum width the column can be. This can be
+ overridden for the last column, if the tree_view is
+ actually wider than the sum of all of the columns
+ requested_widths.
+
+The following invariants are true:
+
+min_width is less than or equal to width
+
+max_width is greater than or equal to width
+
+(sizing == GTK_TREE_VIEW_COLUMN_FIXED) => (requested_width == fixed_width)
+
+(column != last visible column) => width == requested_width
+
+
+/* Functions needed by gtktreeview for gtktreeviewcolumn */
+size_request_button
+set_width (for resizing resizable columns)
+calculate_width
gtkcurve.h \
gtkcellrenderer.h \
gtkcellrenderertext.h \
- gtkcellrenderertextpixbuf.h \
gtkcellrenderertoggle.h \
gtkcellrendererpixbuf.h \
gtkdebug.h \
gtkcalendar.c \
gtkcellrenderer.c \
gtkcellrenderertext.c \
- gtkcellrenderertextpixbuf.c \
gtkcellrenderertoggle.c \
gtkcellrendererpixbuf.c \
gtkcheckbutton.c \
+++ /dev/null
-/* gtkcellrenderertextpixbuf.c
- * Copyright (C) 2000 Red Hat, Inc., Jonathan Blandford <jrb@redhat.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- */
-
-#include <stdlib.h>
-#include "gtkcellrenderertextpixbuf.h"
-#include "gtkintl.h"
-
-enum {
- PROP_ZERO,
- PROP_PIXBUF_POS,
- PROP_PIXBUF,
- PROP_PIXBUF_XALIGN,
- PROP_PIXBUF_YALIGN,
- PROP_PIXBUF_XPAD,
- PROP_PIXBUF_YPAD
-};
-
-
-static void gtk_cell_renderer_text_pixbuf_get_property (GObject *object,
- guint param_id,
- GValue *value,
- GParamSpec *pspec);
-static void gtk_cell_renderer_text_pixbuf_set_property (GObject *object,
- guint param_id,
- const GValue *value,
- GParamSpec *pspec);
-static void gtk_cell_renderer_text_pixbuf_init (GtkCellRendererTextPixbuf *celltextpixbuf);
-static void gtk_cell_renderer_text_pixbuf_class_init (GtkCellRendererTextPixbufClass *class);
-static void gtk_cell_renderer_text_pixbuf_get_size (GtkCellRenderer *cell,
- GtkWidget *view,
- GdkRectangle *cell_area,
- gint *x_offset,
- gint *y_offset,
- gint *width,
- gint *height);
-static void gtk_cell_renderer_text_pixbuf_render (GtkCellRenderer *cell,
- GdkWindow *window,
- GtkWidget *view,
- GdkRectangle *background_area,
- GdkRectangle *cell_area,
- GdkRectangle *expose_area,
- guint flags);
-
-
-static GtkCellRendererTextClass *parent_class = NULL;
-
-
-GtkType
-gtk_cell_renderer_text_pixbuf_get_type (void)
-{
- static GtkType cell_text_pixbuf_type = 0;
-
- if (!cell_text_pixbuf_type)
- {
- static const GTypeInfo cell_text_pixbuf_info =
- {
- sizeof (GtkCellRendererTextPixbufClass),
- NULL, /* base_init */
- NULL, /* base_finalize */
- (GClassInitFunc) gtk_cell_renderer_text_pixbuf_class_init,
- NULL, /* class_finalize */
- NULL, /* class_data */
- sizeof (GtkCellRendererTextPixbuf),
- 0, /* n_preallocs */
- (GInstanceInitFunc) gtk_cell_renderer_text_pixbuf_init,
- };
-
- cell_text_pixbuf_type = g_type_register_static (GTK_TYPE_CELL_RENDERER_TEXT, "GtkCellRendererTextPixbuf", &cell_text_pixbuf_info, 0);
- }
-
- return cell_text_pixbuf_type;
-}
-
-static void
-gtk_cell_renderer_text_pixbuf_init (GtkCellRendererTextPixbuf *celltextpixbuf)
-{
- celltextpixbuf->pixbuf = GTK_CELL_RENDERER_PIXBUF (gtk_cell_renderer_pixbuf_new ());
- celltextpixbuf->pixbuf_pos = GTK_POS_LEFT;
-}
-
-static void
-gtk_cell_renderer_text_pixbuf_class_init (GtkCellRendererTextPixbufClass *class)
-{
- GObjectClass *object_class = G_OBJECT_CLASS (class);
- GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (class);
-
- parent_class = g_type_class_peek_parent (class);
-
- object_class->get_property = gtk_cell_renderer_text_pixbuf_get_property;
- object_class->set_property = gtk_cell_renderer_text_pixbuf_set_property;
-
- cell_class->get_size = gtk_cell_renderer_text_pixbuf_get_size;
- cell_class->render = gtk_cell_renderer_text_pixbuf_render;
-
- g_object_class_install_property (object_class,
- PROP_PIXBUF_POS,
- g_param_spec_int ("pixbuf_pos",
- _("Pixbuf location"),
- _("The relative location of the pixbuf to the text."),
- GTK_POS_LEFT,
- GTK_POS_BOTTOM,
- GTK_POS_LEFT,
- G_PARAM_READABLE |
- G_PARAM_WRITABLE));
-
- g_object_class_install_property (object_class,
- PROP_PIXBUF,
- g_param_spec_object ("pixbuf",
- _("Pixbuf Object"),
- _("The pixbuf to render."),
- GDK_TYPE_PIXBUF,
- G_PARAM_READABLE |
- G_PARAM_WRITABLE));
-
- g_object_class_install_property (object_class,
- PROP_PIXBUF_XALIGN,
- g_param_spec_float ("pixbuf_xalign",
- _("pixbuf xalign"),
- _("The x-align of the pixbuf."),
- 0.0,
- 1.0,
- 0.0,
- G_PARAM_READABLE |
- G_PARAM_WRITABLE));
-
- g_object_class_install_property (object_class,
- PROP_PIXBUF_YALIGN,
- g_param_spec_float ("pixbuf_yalign",
- _("pixbuf yalign"),
- _("The y-align of the pixbuf."),
- 0.0,
- 1.0,
- 0.5,
- G_PARAM_READABLE |
- G_PARAM_WRITABLE));
-
- g_object_class_install_property (object_class,
- PROP_PIXBUF_XPAD,
- g_param_spec_uint ("pixbuf_xpad",
- _("pixbuf xpad"),
- _("The xpad of the pixbuf."),
- 0,
- 100,
- 2,
- G_PARAM_READABLE |
- G_PARAM_WRITABLE));
-
- g_object_class_install_property (object_class,
- PROP_PIXBUF_YPAD,
- g_param_spec_uint ("pixbuf_ypad",
- _("pixbuf ypad"),
- _("The ypad of the pixbuf."),
- 0,
- 100,
- 2,
- G_PARAM_READABLE |
- G_PARAM_WRITABLE));
-}
-
-static void
-gtk_cell_renderer_text_pixbuf_get_property (GObject *object,
- guint param_id,
- GValue *value,
- GParamSpec *pspec)
-{
- GtkCellRendererTextPixbuf *celltextpixbuf = GTK_CELL_RENDERER_TEXT_PIXBUF (object);
-
- switch (param_id)
- {
- case PROP_PIXBUF_POS:
- g_value_set_int (value, celltextpixbuf->pixbuf_pos);
- break;
- case PROP_PIXBUF:
- g_object_get_property (G_OBJECT (celltextpixbuf->pixbuf),
- "pixbuf",
- value);
- break;
- case PROP_PIXBUF_XALIGN:
- g_object_get_property (G_OBJECT (celltextpixbuf->pixbuf),
- "xalign",
- value);
- break;
- case PROP_PIXBUF_YALIGN:
- g_object_get_property (G_OBJECT (celltextpixbuf->pixbuf),
- "yalign",
- value);
- break;
- case PROP_PIXBUF_XPAD:
- g_object_get_property (G_OBJECT (celltextpixbuf->pixbuf),
- "xpad",
- value);
- break;
- case PROP_PIXBUF_YPAD:
- g_object_get_property (G_OBJECT (celltextpixbuf->pixbuf),
- "ypad",
- value);
- break;
- default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
- break;
- }
-}
-
-static void
-gtk_cell_renderer_text_pixbuf_set_property (GObject *object,
- guint param_id,
- const GValue *value,
- GParamSpec *pspec)
-{
- GtkCellRendererTextPixbuf *celltextpixbuf = GTK_CELL_RENDERER_TEXT_PIXBUF (object);
-
- switch (param_id)
- {
- case PROP_PIXBUF:
- g_object_set_property (G_OBJECT (celltextpixbuf->pixbuf),
- "pixbuf",
- value);
- g_object_notify (G_OBJECT(object), "pixbuf");
- break;
- case PROP_PIXBUF_POS:
- celltextpixbuf->pixbuf_pos = g_value_get_int (value);
- g_object_notify (G_OBJECT(object), "pixbuf_pos");
- break;
- case PROP_PIXBUF_XALIGN:
- g_object_set_property (G_OBJECT (celltextpixbuf->pixbuf),
- "xalign",
- value);
- g_object_notify (G_OBJECT(object), "pixbuf_xalign");
- break;
- case PROP_PIXBUF_YALIGN:
- g_object_set_property (G_OBJECT (celltextpixbuf->pixbuf),
- "yalign",
- value);
- g_object_notify (G_OBJECT(object), "pixbuf_yalign");
- break;
- case PROP_PIXBUF_XPAD:
- g_object_set_property (G_OBJECT (celltextpixbuf->pixbuf),
- "xpad",
- value);
- g_object_notify (G_OBJECT(object), "pixbuf_xpad");
- break;
- case PROP_PIXBUF_YPAD:
- g_object_set_property (G_OBJECT (celltextpixbuf->pixbuf),
- "ypad",
- value);
- g_object_notify (G_OBJECT(object), "pixbuf_ypad");
- break;
- default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
- break;
- }
-}
-
-/**
- * gtk_cell_renderer_text_pixbuf_new:
- *
- * Creates a new #GtkCellRendererTextPixbuf. Adjust rendering
- * parameters using object properties. Object properties can be set
- * globally (with g_object_set()). Also, with #GtkTreeViewColumn, you
- * can bind a property to a value in a #GtkTreeModel. For example, you
- * can bind the "text" property on the cell renderer to a string value
- * in the model, thus rendering a different string in each row of the
- * #GtkTreeView
- *
- * Return value: the new cell renderer
- **/
-GtkCellRenderer *
-gtk_cell_renderer_text_pixbuf_new (void)
-{
- return GTK_CELL_RENDERER (gtk_type_new (gtk_cell_renderer_text_pixbuf_get_type ()));
-}
-
-typedef void (* CellSizeFunc) (GtkCellRenderer *cell,
- GtkWidget *widget,
- GdkRectangle *rectangle,
- gint *x_offset,
- gint *y_offset,
- gint *width,
- gint *height);
-typedef void (* CellRenderFunc) (GtkCellRenderer *cell,
- GdkWindow *window,
- GtkWidget *widget,
- GdkRectangle *background_area,
- GdkRectangle *cell_area,
- GdkRectangle *expose_area,
- guint flags);
-
-static void
-gtk_cell_renderer_text_pixbuf_get_size (GtkCellRenderer *cell,
- GtkWidget *widget,
- GdkRectangle *cell_area,
- gint *x_offset,
- gint *y_offset,
- gint *width,
- gint *height)
-{
- GtkCellRendererTextPixbuf *celltextpixbuf = (GtkCellRendererTextPixbuf *)cell;
- gint pixbuf_width;
- gint pixbuf_height;
- gint text_width;
- gint text_height;
- gint calc_width;
- gint calc_height;
-
- (* GTK_CELL_RENDERER_CLASS (parent_class)->get_size) (cell, widget, NULL, NULL, NULL, &text_width, &text_height);
- (* GTK_CELL_RENDERER_CLASS (G_OBJECT_GET_CLASS (celltextpixbuf->pixbuf))->get_size) (GTK_CELL_RENDERER (celltextpixbuf->pixbuf),
- widget,
- NULL, NULL, NULL,
- &pixbuf_width,
- &pixbuf_height);
- if (celltextpixbuf->pixbuf_pos == GTK_POS_LEFT ||
- celltextpixbuf->pixbuf_pos == GTK_POS_RIGHT)
- {
- calc_width = pixbuf_width + text_width;
- calc_height = MAX (pixbuf_height, text_height);
- }
- else
- {
- calc_width = MAX (pixbuf_width, text_width);
- calc_height = pixbuf_height + text_height;
- }
-
- if (width)
- *width = calc_width;
- if (height)
- *height = calc_height;
-
- if (cell_area)
- {
- if (x_offset)
- {
- *x_offset = cell->xalign * (cell_area->width - calc_width - (2 * cell->xpad));
- *x_offset = MAX (*x_offset, 0) + cell->xpad;
- }
- if (y_offset)
- {
- *y_offset = cell->yalign * (cell_area->height - calc_height - (2 * cell->ypad));
- *y_offset = MAX (*y_offset, 0) + cell->ypad;
- }
- }
-}
-
-static void
-gtk_cell_renderer_text_pixbuf_render (GtkCellRenderer *cell,
- GdkWindow *window,
- GtkWidget *widget,
- GdkRectangle *background_area,
- GdkRectangle *cell_area,
- GdkRectangle *expose_area,
- guint flags)
-
-{
- GtkCellRendererTextPixbuf *celltextpixbuf = (GtkCellRendererTextPixbuf *) cell;
- CellSizeFunc size_func1, size_func2;
- CellRenderFunc render_func1, render_func2;
- GtkCellRenderer *cell1, *cell2;
- gint tmp_width;
- gint tmp_height;
- GdkRectangle real_cell_area;
-
- if (celltextpixbuf->pixbuf_pos == GTK_POS_LEFT ||
- celltextpixbuf->pixbuf_pos == GTK_POS_TOP)
- {
- size_func1 = GTK_CELL_RENDERER_CLASS (G_OBJECT_GET_CLASS (celltextpixbuf->pixbuf))->get_size;
- render_func1 = GTK_CELL_RENDERER_CLASS (G_OBJECT_GET_CLASS (celltextpixbuf->pixbuf))->render;
- cell1 = GTK_CELL_RENDERER (celltextpixbuf->pixbuf);
-
- size_func2 = GTK_CELL_RENDERER_CLASS (parent_class)->get_size;
- render_func2 = GTK_CELL_RENDERER_CLASS (parent_class)->render;
- cell2 = cell;
- }
- else
- {
- size_func1 = GTK_CELL_RENDERER_CLASS (parent_class)->get_size;
- render_func1 = GTK_CELL_RENDERER_CLASS (parent_class)->render;
- cell1 = cell;
-
- size_func2 = GTK_CELL_RENDERER_CLASS (G_OBJECT_GET_CLASS (celltextpixbuf->pixbuf))->get_size;
- render_func2 = GTK_CELL_RENDERER_CLASS (G_OBJECT_GET_CLASS (celltextpixbuf->pixbuf))->render;
- cell2 = GTK_CELL_RENDERER (celltextpixbuf->pixbuf);
- }
-
- (size_func1) (cell1, widget, NULL, NULL, NULL, &tmp_width, &tmp_height);
-
- real_cell_area.x = cell_area->x;
- real_cell_area.y = cell_area->y;
-
- if (celltextpixbuf->pixbuf_pos == GTK_POS_LEFT ||
- celltextpixbuf->pixbuf_pos == GTK_POS_RIGHT)
- {
- real_cell_area.width = MIN (tmp_width, cell_area->width);
- real_cell_area.height = cell_area->height;
- }
- else
- {
- real_cell_area.height = MIN (tmp_height, cell_area->height);
- real_cell_area.width = cell_area->width;
- }
-
- (render_func1) (cell1,
- window,
- widget,
- background_area,
- &real_cell_area,
- expose_area,
- flags);
-
- if (celltextpixbuf->pixbuf_pos == GTK_POS_LEFT ||
- celltextpixbuf->pixbuf_pos == GTK_POS_RIGHT)
- {
- real_cell_area.x = real_cell_area.x + real_cell_area.width;
- real_cell_area.width = cell_area->width - real_cell_area.width;
- }
- else
- {
- real_cell_area.y = real_cell_area.y + real_cell_area.height;
- real_cell_area.height = cell_area->height - real_cell_area.height;
- }
-
- (render_func2 ) (cell2,
- window,
- widget,
- background_area,
- &real_cell_area,
- expose_area,
- flags);
-}
+++ /dev/null
-/* gtkcellrenderertextpixbuf.h
- * Copyright (C) 2000 Red Hat, Inc., Jonathan Blandford <jrb@redhat.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- */
-
-#ifndef __GTK_CELL_RENDERER_TEXT_PIXBUF_H__
-#define __GTK_CELL_RENDERER_TEXT_PIXBUF_H__
-
-#include <gtk/gtkcellrenderertext.h>
-#include <gtk/gtkcellrendererpixbuf.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-#define GTK_TYPE_CELL_RENDERER_TEXT_PIXBUF (gtk_cell_renderer_text_pixbuf_get_type ())
-#define GTK_CELL_RENDERER_TEXT_PIXBUF(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_CELL_RENDERER_TEXT_PIXBUF, GtkCellRendererTextPixbuf))
-#define GTK_CELL_RENDERER_TEXT_PIXBUF_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_RENDERER_TEXT_PIXBUF, GtkCellRendererTextPixbufClass))
-#define GTK_IS_CELL_RENDERER_TEXT_PIXBUF(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_CELL_RENDERER_TEXT_PIXBUF))
-#define GTK_IS_CELL_RENDERER_TEXT_PIXBUF_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((obj), GTK_TYPE_CELL_RENDERER_TEXT_PIXBUF))
-#define GTK_CELL_RENDERER_TEXT_PIXBUF_GET_CLASS(obj) (GTK_CHECK_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER_TEXT_PIXBUF, GtkCellRendererTextPixbufClass))
-
-typedef struct _GtkCellRendererTextPixbuf GtkCellRendererTextPixbuf;
-typedef struct _GtkCellRendererTextPixbufClass GtkCellRendererTextPixbufClass;
-
-struct _GtkCellRendererTextPixbuf
-{
- GtkCellRendererText parent;
-
- /*< private >*/
- GtkCellRendererPixbuf *pixbuf;
- GtkPositionType pixbuf_pos;
-};
-
-struct _GtkCellRendererTextPixbufClass
-{
- GtkCellRendererTextClass parent_class;
-};
-
-GtkType gtk_cell_renderer_text_pixbuf_get_type (void);
-GtkCellRenderer *gtk_cell_renderer_text_pixbuf_new (void);
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-
-#endif /* __GTK_CELL_RENDERER_TEXT_PIXBUF_H__ */
* Boston, MA 02111-1307, USA.
*/
+/* A Red-Black Tree implementation used specifically by GtkTreeView.
+ */
#ifndef __GTK_RBTREE_H__
#define __GTK_RBTREE_H__
GtkRBTree *tree,
GtkTreeIter *iter,
gint depth);
-static void gtk_tree_view_check_dirty (GtkTreeView *tree_view);
+static void gtk_tree_view_check_dirty_and_clean (GtkTreeView *tree_view);
static void gtk_tree_view_clamp_node_visible (GtkTreeView *tree_view,
GtkRBTree *tree,
GtkRBNode *node);
tree_view = GTK_TREE_VIEW (widget);
- gtk_tree_view_check_dirty (GTK_TREE_VIEW (widget));
+ gtk_tree_view_check_dirty_and_clean (GTK_TREE_VIEW (widget));
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
/* Make the main, clipping window */
continue;
allocation.x = width;
- allocation.width = column->displayed_width;
+ allocation.width = column->width;
width += column->width;
gtk_widget_size_allocate (column->button, &allocation);
tree_view = GTK_TREE_VIEW (widget);
- gtk_tree_view_check_dirty (tree_view);
+ gtk_tree_view_check_dirty_and_clean (tree_view);
tmp_list = tree_view->priv->children;
if (!column->visible)
continue;
- background_area.width = column->displayed_width;
+ background_area.width = column->width;
if (gtk_tree_view_is_expander_column (tree_view, column) &&
TREE_VIEW_DRAW_EXPANDERS(tree_view))
{
cell_area.x = tree_view->priv->focus_column->button->allocation.x;
cell_area.y = y;
- cell_area.width = tree_view->priv->focus_column->displayed_width;
+ cell_area.width = tree_view->priv->focus_column->width;
cell_area.height = CELL_HEIGHT (node, vertical_separator);
gtk_tree_view_column_cell_get_size (tree_view->priv->focus_column,
if (tree_view->priv->tree == NULL)
return TRUE;
- gtk_tree_view_check_dirty (GTK_TREE_VIEW (widget));
+ gtk_tree_view_check_dirty_and_clean (GTK_TREE_VIEW (widget));
/* we want to account for a potential HEADER offset.
* That is, if the header exists, we want to offset our event by its
* height to find the right node.
continue;
if (cell_offset > event->area.x + event->area.width ||
- cell_offset + column->displayed_width < event->area.x)
+ cell_offset + column->width < event->area.x)
{
- cell_offset += column->displayed_width;
+ cell_offset += column->width;
continue;
}
background_area.x = cell_offset;
- background_area.width = column->displayed_width;
+ background_area.width = column->width;
cell_area = background_area;
cell_area.y += vertical_separator / 2;
&event->area,
flags);
}
- cell_offset += column->displayed_width;
+ cell_offset += column->width;
}
if (node == cursor && GTK_WIDGET_HAS_FOCUS (widget))
if (GTK_TREE_VIEW_COLUMN (list->data)->visible)
{
GTK_TREE_VIEW_COLUMN (list->data)->dirty = TRUE;
+ gtk_tree_view_column_cell_set_dirty (GTK_TREE_VIEW_COLUMN (list->data));
break;
}
}
for (list = tree_view->priv->columns; list; list = list->next)
if (((GtkTreeViewColumn *)list->data)->visible &&
((GtkTreeViewColumn *)list->data)->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
- ((GtkTreeViewColumn *)list->data)->dirty = TRUE;
+ gtk_tree_view_column_cell_set_dirty ((GtkTreeViewColumn *)list->data);
/* Ensure we don't have a dangling pointer to a dead node */
ensure_unprelighted (tree_view);
if (x2)
{
if (column->visible)
- *x2 = total_width + column->displayed_width;
+ *x2 = total_width + column->width;
else
*x2 = total_width; /* width of 0 */
}
NULL, NULL, NULL,
&width, NULL);
}
+
if (gtk_tree_view_is_expander_column (tree_view, column) &&
TREE_VIEW_DRAW_EXPANDERS (tree_view))
{
if (depth * tree_view->priv->tab_offset + width > column->width)
{
- column->dirty = TRUE;
+ gtk_tree_view_column_cell_set_dirty (column);
retval = TRUE;
}
}
{
if (width > column->width)
{
- column->dirty = TRUE;
+ gtk_tree_view_column_cell_set_dirty (column);
retval = TRUE;
}
}
}
+/**
+ * gtk_tree_view_check_dirty_and_clean:
+ * @tree_view: A #GtkTreeView
+ *
+ * Does all the actual sizing for
+ **/
static void
-gtk_tree_view_check_dirty (GtkTreeView *tree_view)
+gtk_tree_view_check_dirty_and_clean (GtkTreeView *tree_view)
{
GtkTreePath *path;
gboolean dirty = FALSE;
continue;
width += column->width;
- column->displayed_width = (CLAMP (column->width, (column->min_width!=-1)?column->min_width:column->width, (column->max_width!=-1)?column->max_width:column->width));
+ column->width = (CLAMP (column->width, (column->min_width!=-1)?column->min_width:column->width, (column->max_width!=-1)?column->max_width:column->width));
}
column = GTK_TREE_VIEW_COLUMN (last_column->data);
- column->displayed_width = MAX (GTK_WIDGET (tree_view)->allocation.width, tree_view->priv->width) - width;
+ column->width = MAX (GTK_WIDGET (tree_view)->allocation.width, tree_view->priv->width) - width;
}
static void
GtkRBTree *cursor_tree = NULL;
GtkRBNode *cursor_node = NULL;
GtkTreePath *cursor_path = NULL;
-
- g_print ("gtk_tree_view_move_cursor_left_right\n");
+ GtkTreeViewColumn *column;
+ GtkTreeIter iter;
+ GList *list;
+ gboolean found_column = FALSE;
if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
else
return;
- _gtk_tree_view_find_node (tree_view, cursor_path,
- &cursor_tree, &cursor_node);
+ _gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node);
+ if (cursor_tree == NULL)
+ return;
+ if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) == FALSE)
+ {
+ gtk_tree_path_free (cursor_path);
+ return;
+ }
gtk_tree_path_free (cursor_path);
+ list = tree_view->priv->columns;
+ if (tree_view->priv->focus_column)
+ {
+ for (list = tree_view->priv->columns; list; list = list->next)
+ {
+ if (list->data == tree_view->priv->focus_column)
+ break;
+ }
+ }
+
+ while (list)
+ {
+ column = list->data;
+ if (column->visible == FALSE)
+ goto loop_end;
+
+ gtk_tree_view_column_cell_set_cell_data (column,
+ tree_view->priv->model,
+ &iter,
+ GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
+ cursor_node->children?TRUE:FALSE);
+ if (gtk_tree_view_column_cell_can_focus (column))
+ {
+ if (gtk_tree_view_column_cell_focus (column, count, FALSE))
+ {
+ tree_view->priv->focus_column = column;
+ found_column = TRUE;
+ break;
+ }
+ }
+ loop_end:
+ if (count == 1)
+ list = list->next;
+ else
+ list = list->prev;
+ }
+ if (found_column)
+ {
+ gtk_tree_view_queue_draw_node (tree_view,
+ cursor_tree,
+ cursor_node,
+ NULL);
+ return;
+ }
+ g_print ("scroll now!\n");
}
static void
column = list->data;
if (column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
continue;
- column->dirty = TRUE;
+ gtk_tree_view_column_cell_set_dirty (column);
dirty = TRUE;
}
tmp_column = GTK_TREE_VIEW_COLUMN (list->data);
if (tmp_column->visible)
- tmp_column->dirty = TRUE;
+ gtk_tree_view_column_cell_set_dirty (tmp_column);
}
if (tree_view->priv->n_columns == 0 &&
{
column = GTK_TREE_VIEW_COLUMN (list->data);
if (column->visible)
- column->dirty = TRUE;
+ gtk_tree_view_column_cell_set_dirty (column);
}
gtk_widget_queue_resize (GTK_WIDGET (tree_view));
}
_gtk_tree_view_update_size (tree_view);
}
-static void
-gtk_tree_view_collapse_all_helper (GtkRBTree *tree,
- GtkRBNode *node,
- gpointer data)
-{
- if (node->children)
- {
- GtkTreePath *path;
- GtkTreeIter iter;
-
- path = _gtk_tree_view_find_path (GTK_TREE_VIEW (data),
- node->children,
- node->children->root);
- gtk_tree_model_get_iter (GTK_TREE_VIEW (data)->priv->model,
- &iter,
- path);
- gtk_tree_view_discover_dirty (GTK_TREE_VIEW (data),
- node->children,
- &iter,
- gtk_tree_path_get_depth (path));
-
- /* Ensure we don't have a dangling pointer to a dead node */
- ensure_unprelighted (GTK_TREE_VIEW (data));
-
- _gtk_rbtree_remove (node->children);
- gtk_tree_path_free (path);
- }
-}
-
/* Timeout to animate the expander during expands and collapses */
static gboolean
expand_collapse_timeout (gpointer data)
void
gtk_tree_view_collapse_all (GtkTreeView *tree_view)
{
+ GtkRBTree *tree;
+ GtkRBNode *node;
+ GtkTreePath *path;
+ guint *indices;
+
g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
g_return_if_fail (tree_view->priv->tree != NULL);
- _gtk_rbtree_traverse (tree_view->priv->tree,
- tree_view->priv->tree->root,
- G_PRE_ORDER,
- gtk_tree_view_collapse_all_helper,
- tree_view);
+ path = gtk_tree_path_new ();
+ gtk_tree_path_append_index (path, 0);
+ indices = gtk_tree_path_get_indices (path);
- if (GTK_WIDGET_MAPPED (tree_view))
- gtk_widget_queue_draw (GTK_WIDGET (tree_view));
+ tree = tree_view->priv->tree;
+ node = tree->root;
+ while (node && node->left != tree->nil)
+ node = node->left;
+
+ while (node)
+ {
+ if (node->children)
+ gtk_tree_view_real_collapse_row (tree_view, path, tree, node);
+ indices[0]++;
+ node = _gtk_rbtree_next (tree, node);
+ }
+
+ gtk_tree_path_free (path);
}
/* FIXME the bool return values for expand_row and collapse_row are
GtkTreeIter children;
gboolean collapse;
gint x, y;
+ GList *list;
gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_children (tree_view->priv->model, &children, &iter), FALSE);
- gtk_tree_view_discover_dirty (tree_view,
- node->children,
- &children,
- gtk_tree_path_get_depth (path));
+ for (list = tree_view->priv->columns; list; list = list->next)
+ {
+ GtkTreeViewColumn *column = list->data;
+ if (column->visible == FALSE)
+ continue;
+ if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
+ gtk_tree_view_column_cell_set_dirty (column);
+ }
+
if (tree_view->priv->destroy_count_func)
{
GtkTreePath *child_path;
node->children?TRUE:FALSE);
background_area.x = cell_offset;
- background_area.width = column->displayed_width;
+ background_area.width = column->width;
cell_area = background_area;
NULL,
0);
- cell_offset += column->displayed_width;
+ cell_offset += column->width;
}
return drawable;
{
PROP_0,
PROP_VISIBLE,
- PROP_SIZING,
PROP_WIDTH,
+ PROP_SIZING,
+ PROP_FIXED_WIDTH,
PROP_MIN_WIDTH,
PROP_MAX_WIDTH,
PROP_TITLE,
gpointer func_data;
GtkDestroyNotify destroy;
gint requested_width;
- guint16 padding;
guint expand : 1;
- guint fill : 1;
guint pack : 1;
+ guint has_focus : 1;
};
/* Type methods */
va_list args);
static GtkTreeViewColumnCellInfo *gtk_tree_view_column_get_cell_info (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell_renderer);
+static void gtk_tree_view_column_cell_foreach (GtkTreeViewColumn *tree_column,
+ gboolean direction,
+ GFunc function,
+ gpointer data);
TRUE,
G_PARAM_READABLE | G_PARAM_WRITABLE));
+ g_object_class_install_property (object_class,
+ PROP_WIDTH,
+ g_param_spec_int ("width",
+ _("Width"),
+ _("Current width of the column"),
+ 0,
+ G_MAXINT,
+ 0,
+ G_PARAM_READABLE));
g_object_class_install_property (object_class,
PROP_SIZING,
g_param_spec_enum ("sizing",
G_PARAM_READABLE | G_PARAM_WRITABLE));
g_object_class_install_property (object_class,
- PROP_WIDTH,
- g_param_spec_int ("width",
- _("Width"),
- _("Current width of the column"),
+ PROP_FIXED_WIDTH,
+ g_param_spec_int ("fixed_width",
+ _("Fixed Width"),
+ _("Current fixed width of the column"),
1,
G_MAXINT,
1, /* not useful */
_("Minimum allowed width of the column"),
-1,
G_MAXINT,
- 1,
+ -1,
G_PARAM_READABLE | G_PARAM_WRITABLE));
g_object_class_install_property (object_class,
_("Maximum allowed width of the column"),
-1,
G_MAXINT,
- G_MAXINT,
+ -1,
G_PARAM_READABLE | G_PARAM_WRITABLE));
g_object_class_install_property (object_class,
{
tree_column->button = NULL;
tree_column->xalign = 0.0;
- tree_column->width = 1;
+ tree_column->width = 0;
tree_column->requested_width = -1;
tree_column->min_width = -1;
tree_column->max_width = -1;
- tree_column->column_type = GTK_TREE_VIEW_COLUMN_AUTOSIZE;
+ tree_column->column_type = GTK_TREE_VIEW_COLUMN_GROW_ONLY;
tree_column->visible = TRUE;
tree_column->clickable = FALSE;
tree_column->dirty = TRUE;
g_value_get_enum (value));
break;
- case PROP_WIDTH:
- gtk_tree_view_column_set_width (tree_column,
- g_value_get_int (value));
+ case PROP_FIXED_WIDTH:
+ gtk_tree_view_column_set_fixed_width (tree_column,
+ g_value_get_int (value));
break;
case PROP_MIN_WIDTH:
gtk_tree_view_column_get_visible (tree_column));
break;
+ case PROP_WIDTH:
+ g_value_set_int (value,
+ gtk_tree_view_column_get_width (tree_column));
+ break;
+
case PROP_SIZING:
g_value_set_enum (value,
gtk_tree_view_column_get_sizing (tree_column));
break;
- case PROP_WIDTH:
+ case PROP_FIXED_WIDTH:
g_value_set_int (value,
- gtk_tree_view_column_get_width (tree_column));
+ gtk_tree_view_column_get_fixed_width (tree_column));
break;
case PROP_MIN_WIDTH:
}
}
- tree_column->dirty = TRUE;
- gtk_widget_queue_resize (tree_column->tree_view);
+ gtk_tree_view_column_cell_set_dirty (tree_column);
}
/* Button signal handlers
gtk_tree_view_column_set_cell_renderer (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell)
{
- gtk_tree_view_column_pack_start (tree_column, cell, TRUE, TRUE, 0);
+ gtk_tree_view_column_pack_start (tree_column, cell, TRUE);
}
static GtkTreeViewColumnCellInfo *
return NULL;
}
+
/**
* gtk_tree_view_column_pack_start:
* @tree_column: A #GtkTreeViewColumn.
* @cell: The #GtkCellRenderer,
* @expand: TRUE if @cell is to be given extra space allocated to box.
- * @fill: TRUE if @cell is to fill space allocated to it.
- * @padding: extra space in pixels to place on the outside of the cell
*
- * Packs a cell into
**/
void
gtk_tree_view_column_pack_start (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell,
- gboolean expand,
- gboolean fill,
- guint padding)
+ gboolean expand)
{
GtkTreeViewColumnCellInfo *cell_info;
cell_info = g_new0 (GtkTreeViewColumnCellInfo, 1);
cell_info->cell = cell;
cell_info->expand = expand ? TRUE : FALSE;
- cell_info->fill = fill ? TRUE : FALSE;
cell_info->pack = GTK_PACK_START;
+ cell_info->has_focus = 0;
cell_info->attributes = NULL;
tree_column->cell_list = g_list_append (tree_column->cell_list, cell_info);
void
gtk_tree_view_column_pack_end (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell,
- gboolean expand,
- gboolean fill,
- guint padding)
+ gboolean expand)
{
GtkTreeViewColumnCellInfo *cell_info;
cell_info = g_new (GtkTreeViewColumnCellInfo, 1);
cell_info->cell = cell;
cell_info->expand = expand ? TRUE : FALSE;
- cell_info->fill = fill ? TRUE : FALSE;
cell_info->pack = GTK_PACK_END;
+ cell_info->has_focus = 0;
cell_info->attributes = NULL;
tree_column->cell_list = g_list_append (tree_column->cell_list, cell_info);
info->attributes = g_slist_prepend (info->attributes, g_strdup (attribute));
if (tree_column->tree_view)
- {
- tree_column->dirty = TRUE;
- gtk_widget_queue_resize (tree_column->tree_view);
- }
+ gtk_tree_view_column_cell_set_dirty (tree_column);
}
info->destroy = destroy;
if (tree_column->tree_view)
- {
- tree_column->dirty = TRUE;
- gtk_widget_queue_resize (tree_column->tree_view);
- }
+ gtk_tree_view_column_cell_set_dirty (tree_column);
}
info->attributes = NULL;
if (tree_column->tree_view)
- {
- tree_column->dirty = TRUE;
- gtk_widget_queue_resize (tree_column->tree_view);
- }
+ gtk_tree_view_column_cell_set_dirty (tree_column);
}
tree_column->spacing = spacing;
if (tree_column->tree_view)
- {
- tree_column->dirty = TRUE;
- gtk_widget_queue_resize (tree_column->tree_view);
- }
+ gtk_tree_view_column_cell_set_dirty (tree_column);
}
/**
}
/**
- * gtk_tree_view_column_get_size:
+ * gtk_tree_view_column_get_width:
* @tree_column: A #GtkTreeViewColumn.
*
* Returns the current size of the @tree_column in pixels.
*
- * Return value: The current size of the @tree_column.
+ * Return value: The current width of the @tree_column.
**/
gint
-gtk_tree_view_column_get_size (GtkTreeViewColumn *tree_column)
+gtk_tree_view_column_get_width (GtkTreeViewColumn *tree_column)
{
g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
}
/**
- * gtk_tree_view_column_set_width:
+ * gtk_tree_view_column_set_fixed_width:
* @tree_column: A #GtkTreeViewColumn.
* @width: The size to set the @tree_column to.
*
- * Sets the size of the column in pixels, unless the the column type is
- * #GTK_TREE_VIEW_COLUMN_AUTOSIZE. In this case, the value is discarded as the
- * size of the column is based on the calculated width of the column. The
+ * Sets the size of the column in pixels. This is meaningful only if the sizing
+ * type is #GTK_TREE_VIEW_COLUMN_FIXED. In this case, the value is discarded
+ * as the size of the column is based on the calculated width of the column. The
* width is clamped to the min/max width for the column.
**/
void
-gtk_tree_view_column_set_width (GtkTreeViewColumn *tree_column,
- gint width)
+gtk_tree_view_column_set_fixed_width (GtkTreeViewColumn *tree_column,
+ gint width)
{
g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
g_return_if_fail (width > 0);
if (tree_column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
return;
+ tree_column->fixed_width = width;
tree_column->requested_width = width;
_gtk_tree_view_column_set_width (tree_column, width);
}
/**
- * gtk_tree_view_column_get_width:
+ * gtk_tree_view_column_get_fixed_width:
* @tree_column: a #GtkTreeViewColumn
*
- * Gets the value set by gtk_tree_view_column_set_width(). This may not be the
+ * Gets the fixed width of the column. This value is only meaning may not be the
* actual width of the column on the screen, just what is requested.
*
- * Return value: the width of the column
+ * Return value: the fixed width of the column
**/
gint
-gtk_tree_view_column_get_width (GtkTreeViewColumn *tree_column)
+gtk_tree_view_column_get_fixed_width (GtkTreeViewColumn *tree_column)
{
g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
- return tree_column->width;
+ return tree_column->fixed_width;
}
/**
}
}
-
+#if 0
/**
* gtk_tree_view_column_cell_get_size:
* @tree_column: A #GtkTreeViewColumn.
height);
}
+#endif
+void
+gtk_tree_view_column_cell_get_size (GtkTreeViewColumn *tree_column,
+ GdkRectangle *cell_area,
+ gint *x_offset,
+ gint *y_offset,
+ gint *width,
+ gint *height)
+{
+ GList *list;
+ gboolean first_cell = TRUE;
+
+ g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
+
+ if (height)
+ * height = 0;
+ if (width)
+ * width = 0;
+
+ for (list = tree_column->cell_list; list; list = list->next)
+ {
+ GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data;
+ gboolean visible;
+ gint new_height = 0;
+ gint new_width = 0;
+ g_object_get (info->cell, "visible", &visible, NULL);
+
+ if (visible == FALSE)
+ continue;
+
+ if (first_cell == FALSE && *width)
+ *width += tree_column->spacing;
+
+ gtk_cell_renderer_get_size (info->cell,
+ tree_column->tree_view,
+ cell_area,
+ x_offset,
+ y_offset,
+ &new_width,
+ &new_height);
+
+ if (height)
+ * height = MAX (*height, new_height);
+ info->requested_width = MAX (info->requested_width, new_width);
+ if (width)
+ * width += info->requested_width;
+ first_cell = TRUE;
+ }
+}
/**
* gtk_tree_view_column_cell_render:
GdkRectangle *expose_area,
guint flags)
{
- gboolean visible;
+ GList *list;
+ GdkRectangle real_cell_area;
+ gint expand_cell_count = 0;
+ gint full_requested_width = 0;
+ gint extra_space;
+
g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
+ g_return_if_fail (background_area != NULL);
+ g_return_if_fail (cell_area != NULL);
+ g_return_if_fail (expose_area != NULL);
- g_object_get (G_OBJECT ((((GtkTreeViewColumnCellInfo *) tree_column->cell_list->data)->cell)), "visible", &visible, NULL);
- if (visible)
- gtk_cell_renderer_render (((GtkTreeViewColumnCellInfo *) tree_column->cell_list->data)->cell,
- window,
- tree_column->tree_view,
- background_area,
- cell_area,
- expose_area,
- flags);
+ real_cell_area = *cell_area;
+
+ /* Find out how my extra space we have to allocate */
+ for (list = tree_column->cell_list; list; list = list->next)
+ {
+ GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data;
+ gboolean visible;
+
+ g_object_get (info->cell, "visible", &visible, NULL);
+ if (visible == FALSE)
+ continue;
+
+ if (info->expand == TRUE)
+ expand_cell_count ++;
+ full_requested_width += info->requested_width;
+ }
+
+ extra_space = cell_area->width - full_requested_width;
+ if (extra_space < 0)
+ extra_space = 0;
+
+ for (list = tree_column->cell_list; list; list = list->next)
+ {
+ GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data;
+ gboolean visible;
+
+ if (info->pack == GTK_PACK_END)
+ continue;
+
+ g_object_get (info->cell, "visible", &visible, NULL);
+ if (visible == FALSE)
+ continue;
+
+ real_cell_area.width = info->requested_width +
+ (info->expand?extra_space:0);
+ gtk_cell_renderer_render (info->cell,
+ window,
+ tree_column->tree_view,
+ background_area,
+ &real_cell_area,
+ expose_area,
+ flags);
+ real_cell_area.x += (info->requested_width + tree_column->spacing);
+ }
+ for (list = g_list_last (tree_column->cell_list); list; list = list->prev)
+ {
+ GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data;
+ gboolean visible;
+
+ if (info->pack == GTK_PACK_START)
+ continue;
+
+ g_object_get (info->cell, "visible", &visible, NULL);
+ if (visible == FALSE)
+ continue;
+
+ real_cell_area.width = info->requested_width +
+ (info->expand?extra_space:0);
+ gtk_cell_renderer_render (info->cell,
+ window,
+ tree_column->tree_view,
+ background_area,
+ &real_cell_area,
+ expose_area,
+ flags);
+ real_cell_area.x += (info->requested_width + tree_column->spacing);
+ }
}
/**
return FALSE;
}
+
+gboolean
+gtk_tree_view_column_cell_focus (GtkTreeViewColumn *tree_column,
+ gint direction,
+ gboolean unfocus)
+{
+ GList *list;
+ gboolean visible;
+ gboolean can_activate;
+
+}
+
gboolean
gtk_tree_view_column_cell_can_focus (GtkTreeViewColumn *tree_column)
{
gtk_tree_view_column_cell_is_visible (GtkTreeViewColumn *tree_column)
{
GList *list;
- gboolean visible;
for (list = tree_column->cell_list; list; list = list->next)
{
GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data;
- g_object_get (G_OBJECT (info->cell),
- "visible", &visible,
- NULL);
+ gboolean visible;
+
+ g_object_get (G_OBJECT (info->cell), "visible", &visible, NULL);
+
if (visible)
return TRUE;
}
return FALSE;
}
+
+void
+gtk_tree_view_column_cell_set_dirty (GtkTreeViewColumn *tree_column)
+{
+ GList *list;
+
+ for (list = tree_column->cell_list; list; list = list->next)
+ {
+ GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data;
+
+ info->requested_width = 0;
+ }
+ tree_column->dirty = TRUE;
+
+ g_print ("in gtk_tree_view_column_cell_set_dirty\n");
+ if (tree_column->tree_view)
+ gtk_widget_queue_resize (tree_column->tree_view);
+}
+
+
+#if 0
+static void
+gtk_tree_view_column_cell_foreach (GtkTreeViewColumn *tree_column,
+ gboolean direction,
+ GFunc function,
+ gpointer data)
+{
+ GList *list;
+ GtkTreeViewColumnCellInfo *info;
+
+ if (direction == 1)
+ {
+ for (list = tree_column->cell_list; list; list = list->next)
+ {
+ info = list->data;
+ if (info->pack == GTK_PACK_END)
+ continue;
+ if ((*function) (info, data))
+ return;
+ }
+
+ for (list = g_list_llast (tree_column->cell_list); list; list = list->prev)
+ {
+ info = list->data;
+ if (info->pack == GTK_PACK_START)
+ continue;
+ if ((*function) (info, data))
+ return;
+ }
+ }
+ else
+ {
+ for (list = g_list_llast (tree_column->cell_list); list; list = list->prev)
+ {
+ info = list->data;
+ if (info->pack == GTK_PACK_START)
+ continue;
+ if ((*function) (info, data))
+ return;
+ }
+ for (list = tree_column->cell_list; list; list = list->next)
+ {
+ info = list->data;
+ if (info->pack == GTK_PACK_END)
+ continue;
+ if ((*function) (info, data))
+ return;
+ }
+
+ }
+}
+#endif
typedef enum
{
+ GTK_TREE_VIEW_COLUMN_GROW_ONLY,
GTK_TREE_VIEW_COLUMN_RESIZABLE,
GTK_TREE_VIEW_COLUMN_AUTOSIZE,
GTK_TREE_VIEW_COLUMN_FIXED
guint property_changed_signal;
gint spacing;
+ gint fixed_width;
gint width;
gint requested_width;
gint min_width;
gint max_width;
- gint displayed_width;
/* dragging columns */
gint drag_x;
GtkCellRenderer *cell);
void gtk_tree_view_column_pack_start (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell,
- gboolean expand,
- gboolean fill,
- guint padding);
+ gboolean expand);
void gtk_tree_view_column_pack_end (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell,
- gboolean expand,
- gboolean fill,
- guint padding);
+ gboolean expand);
void gtk_tree_view_column_clear (GtkTreeViewColumn *tree_column);
GList *gtk_tree_view_column_get_cell_renderers (GtkTreeViewColumn *tree_column);
void gtk_tree_view_column_add_attribute (GtkTreeViewColumn *tree_column,
GtkTreeViewColumnSizing type);
GtkTreeViewColumnSizing gtk_tree_view_column_get_sizing (GtkTreeViewColumn *tree_column);
gint gtk_tree_view_column_get_width (GtkTreeViewColumn *tree_column);
-void gtk_tree_view_column_set_width (GtkTreeViewColumn *tree_column,
- gint width);
+gint gtk_tree_view_column_get_fixed_width (GtkTreeViewColumn *tree_column);
+void gtk_tree_view_column_set_fixed_width (GtkTreeViewColumn *tree_column,
+ gint fixed_width);
void gtk_tree_view_column_set_min_width (GtkTreeViewColumn *tree_column,
gint min_width);
gint gtk_tree_view_column_get_min_width (GtkTreeViewColumn *tree_column);
GdkRectangle *background_area,
GdkRectangle *cell_area,
guint flags);
+gboolean gtk_tree_view_column_cell_focus (GtkTreeViewColumn *tree_column,
+ gint direction,
+ gboolean unfocus);
gboolean gtk_tree_view_column_cell_can_focus (GtkTreeViewColumn *tree_column);
gboolean gtk_tree_view_column_cell_is_visible (GtkTreeViewColumn *tree_column);
+void gtk_tree_view_column_cell_set_dirty (GtkTreeViewColumn *tree_column);
#ifdef __cplusplus
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (tree_view), col_offset - 1);
gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_FIXED);
- gtk_tree_view_column_set_width (GTK_TREE_VIEW_COLUMN (column), 50);
+ gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 50);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
/* Havoc Column */
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (tree_view), col_offset - 1);
gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_FIXED);
- gtk_tree_view_column_set_width (GTK_TREE_VIEW_COLUMN (column), 50);
+ gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 50);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
/* Tim Column */
column = gtk_tree_view_get_column (GTK_TREE_VIEW (tree_view), col_offset - 1);
gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
- gtk_tree_view_column_set_width (GTK_TREE_VIEW_COLUMN (column), 50);
+ gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 50);
/* Owen Column */
renderer = gtk_cell_renderer_toggle_new ();
column = gtk_tree_view_get_column (GTK_TREE_VIEW (tree_view), col_offset - 1);
gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
- gtk_tree_view_column_set_width (GTK_TREE_VIEW_COLUMN (column), 50);
+ gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 50);
/* Owen Column */
renderer = gtk_cell_renderer_toggle_new ();
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (tree_view), col_offset - 1);
gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_FIXED);
- gtk_tree_view_column_set_width (GTK_TREE_VIEW_COLUMN (column), 50);
+ gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 50);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_container_add (GTK_CONTAINER (scrolled_window), tree_view);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
- rend = gtk_cell_renderer_text_pixbuf_new ();
+ col = gtk_tree_view_column_new();
+ gtk_tree_view_column_set_title (col, "Column 2");
- col = gtk_tree_view_column_new_with_attributes ("Column 2",
- rend,
- "text", 0,
- "pixbuf", 2,
- NULL);
+ rend = gtk_cell_renderer_pixbuf_new ();
+ gtk_tree_view_column_pack_start (col, rend, FALSE);
+ gtk_tree_view_column_add_attribute (col, rend, "pixbuf", 2);
+ rend = gtk_cell_renderer_text_new ();
+ gtk_tree_view_column_pack_start (col, rend, TRUE);
+ gtk_tree_view_column_add_attribute (col, rend, "text", 0);
setup_column (col);
projects / gtk4.git / commitdiff